home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Talking Clock Pro™ 2.0.1 / Talking Clock Pro Source / Controller / Source / str.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-03  |  2.4 KB  |  152 lines  |  [TEXT/CWIE]
  1. /*
  2.  * str.c
  3.  */
  4.  
  5. #include <Types.h>
  6. #include <ToolUtils.h>
  7. #include <Memory.h>
  8.  
  9. #include "str.h"
  10. #include "x.h"
  11.  
  12.  
  13. void
  14. StrGet ( short id , unsigned char * buf , short maxLen ) {
  15.  
  16. StringHandle sh = GetString ( id ) ;
  17. register unsigned char * src , * dst ;
  18.  
  19.     FailNil ( sh ) ;
  20.     if ( * * sh < maxLen ) {
  21.         maxLen = * * sh ;
  22.     }
  23.     dst = buf ;
  24.     src = ( * sh ) + 1 ;
  25.     * ( dst ++ ) = maxLen ;
  26.     while ( maxLen -- > 0 ) {
  27.         * ( dst ++ ) = * ( src ++ ) ;
  28.     }
  29. }
  30.  
  31.  
  32. void
  33. CopyC2P ( char * cStr , unsigned char * pStr ) {
  34.  
  35. register char * src = cStr ;
  36. register unsigned char * dst = pStr + 1 ;
  37.  
  38.     while ( * src ) {
  39.         * ( dst ++ ) = * ( src ++ ) ;
  40.     }
  41.     * pStr = dst - pStr - 1 ;
  42. }
  43.  
  44.  
  45. #ifndef useasm
  46. void
  47. ClearMem ( void * mem , int size ) {
  48.  
  49. register char * ptr = mem ;
  50. register int cnt = size ;
  51. register long * lptr ;
  52.  
  53.     if ( size > 15 ) { /* Optimize by clearing longs */
  54.  
  55.         cnt = ( ( long ) ptr ) & 3 ; /* Align to longword */
  56.         size -= cnt ;
  57.         while ( cnt -- ) {
  58.             * ( ptr ++ ) = 0 ;
  59.         }
  60.  
  61.         cnt = size >> 2 ; /* Num longwords to clear */
  62.         lptr = ( long * ) ptr ;
  63.         while ( cnt -- ) {
  64.             * ( lptr ++ ) = 0L ;
  65.         }
  66.         ptr = ( char * ) lptr ;
  67.  
  68.         cnt = size & 3 ; /* This many bytes left to clear */
  69.     }
  70.  
  71.     while ( cnt -- ) { /* Clear bytewise */
  72.         * ( ptr ++ ) = 0 ;
  73.     }
  74. }
  75. #else
  76. #define INT w
  77. #error BUGGY
  78. static void
  79. AsmClearMem ( ) {
  80.     asm {
  81. extern ClearMem :
  82.         move.INT    8(a7) ,    d0
  83.         move.l        4(a7) ,    a0
  84.         cmp.INT        #15 ,    d0
  85.         bge            @1
  86.         move.INT    a0 ,    d1
  87.         and            #3 ,    d1
  88.         sub            d1 ,    d0
  89.         bra            @2
  90. @3:        clr.b        (a0)+
  91. @2:        dbra        d1 ,    @3
  92.         move.INT    d0 ,    d1
  93.         and            #3 ,    d0
  94.         asr            #2 ,    d1
  95.         bra            @4
  96. @5:        clr.l        (a0)+
  97. @4:        dbra        d1 ,    @5
  98.         bra            @1
  99. @6:        clr.b        (a0)+
  100. @1:        dbra        d0 ,    @6
  101.     }
  102. }
  103. #endif
  104.  
  105.  
  106. void
  107. ConcatPStrings ( unsigned char * dest , unsigned char * src ) {
  108.  
  109. int newLen = * dest + * src ;
  110.  
  111.     if ( newLen > 255 ) {
  112.         newLen = 255 ;
  113.     }
  114.     MemCopy ( src + 1 , dest + * dest + 1 , newLen - * dest ) ;
  115.     * dest = newLen ;
  116. }
  117.  
  118.  
  119. void
  120. MemCopy ( void * src , void * dst , int len ) {
  121.  
  122. register int ll = len ;
  123. register char * s = src ;
  124. register char * d = dst ;
  125.  
  126.     if ( d == s || ll < 1 ) {
  127.         return ;
  128.     }
  129.     if ( ll > 512 ) { /* Copy performance outweighs cache flush */
  130.         BlockMove ( src , dst , len ) ;
  131.         return ;
  132.     }
  133.     if ( d > s && d - ll < s ) {
  134.         d += ll ;
  135.         s += ll ;
  136.         while ( ll -- ) {
  137.             * ( -- d ) = * ( -- s ) ;
  138.         }
  139.     } else {
  140.         while ( ll -- ) {
  141.             * ( d ++ ) = * ( s ++ ) ;
  142.         }
  143.     }
  144. }
  145.  
  146.  
  147. void
  148. CopyPString ( unsigned char * src , unsigned char * dst ) {
  149.  
  150.     MemCopy ( src , dst , ( * src ) + 1 ) ;
  151. }
  152.